home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / langs / prolog68.zoo / prolog.68 / doc / readme < prev   
Encoding:
Text File  |  1994-06-03  |  23.7 KB  |  707 lines

  1. -------------------------------------------------------------------------------
  2.  
  3.  
  4.        /¯¯¯¯¯)          /¯)                /¯¯¯¯¯) /¯¯¯¯¯)
  5.       / /¯) /         / /               / ____/ / /¯) /
  6.      / (_/ /        / /              / /      / (_/ /
  7.     / ____/ /¯¯¯¯) /¯¯¯¯¯) / / /¯¯¯¯¯) /¯¯¯¯¯) /¯¯¯) /  ¯¯¯) /     /
  8.        / /     / /¯¯¯ / /¯) / / / / /¯) / / /¯) / (___/ / /¯) / / /¯) /
  9.       / /     / /    / (_/ / / / / (_/ / / (_/ /       / (_/ / / (_/ /
  10.      (_/     (_/    (_____/ (_/ (_____/ (___  /       (_____/ (_____/
  11.                        / /
  12.                       /¯¯¯¯ /
  13.                      (_____/
  14.  
  15.                  (pre-release version)
  16.  
  17.  
  18.  
  19.                © Copyright 1989-1994 Jens Kilian
  20.                   All rights reserved
  21.  
  22.  
  23. ------- Shipping list ---------------------------------------------------------
  24.  
  25.     CODES            Pre-compiled versions of the compiler
  26.         BUILTINS.WAM    and run-time system
  27.         DEBUGGER.WAM
  28.         DRIVER.WAM
  29.         DSTRUCT.WAM
  30.         ENCODER.WAM
  31.         INDEXER.WAM
  32.         LIBRARY.WAM
  33.         SHELL.WAM
  34.         TMPALLOC.WAM
  35.         XLATOR.WAM
  36.  
  37.     DOC
  38.         LIESMICH        This document (German version)
  39.         README        This document (English version)
  40.  
  41.     INIT.WAM        Bootstrap information
  42.     PROLOG.LST
  43.  
  44.     WAM.TOS         Main program (emulator, primitive operations)
  45.     MWAM.TOS        Main program, MiNT library (untested!)
  46.  
  47. ------- Overview --------------------------------------------------------------
  48.  
  49. This package contains pre-release version 0.94.17 of Prolog-68, a not entirely
  50. new :-) Prolog system for Atari's ST series.  When the program is finished, it
  51. will be made publicly available as free software (NOT public domain software!)
  52. together with the source code.    This will take some time yet.
  53.  
  54. The present version may be freely distributed, but NOT modified or used
  55. commercially.  'Commercial use' includes distribution, if a fee is charged
  56. and if the rate for a single disk exceeds the sum of the disk's price and
  57. the postal (or other carrier's) charge by more than DM 2,- (at a reasonable
  58. rate of exchange, if applicable).
  59.  
  60. Again:    This is a pre-release version, meaning that I don't even guarantee
  61.     the correctness of this document!
  62.  
  63. Prolog-68 is based on the `Warren Abstract Machine'; it contains a compiler
  64. (written in Prolog) which translates program clauses into intermediate code.
  65. This intermediate code is stored (as direct threaded code) and executed by a
  66. simulator.  The system attains a speed of 12 kLIPS on the 'nrev' Benchmark,
  67. which is quite acceptable on an Atari ST.  The program was tested on an ST
  68. with 4MB of main storage, but should be able to run on all Atari computers with
  69. 680x0 processors.  In case of problems with TTs, Falcons or accelerated STs,
  70. please supply accurate error reports; I can't make tests myself because I don't
  71. have access to that kind of hardware.  As usual, `more is better' regarding
  72. main memory; at least 250 KB are required just to load the system.  The files
  73. in the 'CODES' folder contain a pre-translated version of the compiler and user
  74. interface.  DON'T MODIFY THESE FILES UNDER ANY CIRCUMSTANCES, OTHERWISE YOU
  75. WON'T BE ABLE TO START PROLOG-68!
  76.  
  77. ------- Incompatibilities to previous versions --------------------------------
  78.  
  79. Version 0.9 to version 0.91:
  80.  
  81. - On the Prolog level all characters are represented according to the Unicode
  82.   standard (ISO DIS 10646-1.2 Basic Multilingual Plane).  Previous versions
  83.   used extended ASCII according to ISO 8859-1 resp. (still earlier) the Atari
  84.   character set.
  85.   The most important difference is in the representation of line endings in
  86.   text files.  All line endings read in are represented by the Prolog character
  87.   code 16'2028 (ASCII NL = 16'0a is treated as equivalent on output).  Programs
  88.   that use is_endline/1 or is_newline/1 to test for line endings should
  89.   encounter no difficulties; the same holds for using the "\n" escape sequence.
  90.  
  91.   (I will remove this special case in the next version because it gave me more
  92.   problems than benefits.  Sorry.)
  93.  
  94. - According to the upcoming ISO standard, a 'cut' in the precondition of a call
  95.   to '->'/2 has no effect on the rest of the clause.
  96.  
  97. - The predicates constant/1 and nonconstant/1 have disappeared (replace them by
  98.   atomic/1 resp. nonatomic/1).    You don't want to know about this.
  99.  
  100. Version 0.91 to version 0.93:
  101.  
  102. - Line endings are represented by ASCII newlines again, for the reasons
  103.   mentioned above.
  104.  
  105. - The stream opening modes 'read_binary', 'write_binary' and 'append_binary'
  106.   are no longer valid, since their purpose is served by the 'stream options'
  107.   concept from the ISO standard.
  108.  
  109. - It is no longer possible to list or trace compiled predicates.  Access to
  110.   single clauses is only possible for interpreted (dynamic) predicates.  It is
  111.   however still possible to set 'spy points' on compiled predicates in the
  112.   debugger.
  113.  
  114. - The debugger can now be explicitly switched on and off.  It is no longer
  115.   necessary to indicate the predicate to be debugged.  The predicates debug/1
  116.   and trace/1 don't exist any more.
  117.  
  118. Version 0.93 to version 0.94:
  119.  
  120. - absolute_file_name/2 may have different results because it now supports '/'
  121.   as a directory separator (e.g., when running MiNT).
  122.  
  123. ------- Known bugs ------------------------------------------------------------
  124.  
  125. The present version 0.94.17 contains the following bugs (to be fixed in later
  126. versions):
  127.  
  128.     * NUL characters (ASCII 0) are not allowed in atoms' names.
  129.  
  130.     * Some database operations may not have correct update semantics.
  131.       (I.e., a change may be visible to calls that were started before
  132.       the change occurred.)
  133.  
  134. ------- Invocation ------------------------------------------------------------
  135.  
  136. The following are legal command-line options:
  137.  
  138.     -help        Prints a short description of all the options.
  139.  
  140.     -debug        Switches on an internal debugging mode.  As it stands,
  141.             this will be of use to the author only.
  142.  
  143.     -dribble <file> Opens a file into which all characters read from the
  144.             keyboard will be echoed (useful for reporting bugs).
  145.  
  146.     -code     <size> Allocates memory to the code area; this holds all
  147.             long-lived data structures (such as atoms, functors and
  148.             clauses).
  149.  
  150.     -global  <size> Allocates memory to the global area, holding all terms
  151.             created during program execution.
  152.  
  153.     -local     <size> Allocates memory to the local area (used to control
  154.             program execution and to hold local variables).
  155.  
  156.     -reserve <size> Returns memory to the operating system.
  157.  
  158. Prolog-68 stores all data in three big areas of memory.  Their sizes are 
  159. computed at start-up and never changed afterwards.  This restriction may 
  160. cause a Prolog program to abort for lack of memory, even though enough 
  161. free memory is present (future versions will include a mechanism for 
  162. redistributing free memory at run-time).  On computers having little main 
  163. memory, it is thus important to set reasonable sizes for the different 
  164. areas.
  165. If no options are given to it, Prolog-68 uses a very coarse partitioning 
  166. which works well only with large amounts of memory.  On STs with only 1MB 
  167. of RAM, at least the code area should be explicitly set to about 250-300 KB.
  168. If memory is even smaller, 150 KB will be the absolute minimum.
  169.  
  170. To distribute available memory to the various areas, the options '-code',
  171. '-global', '-local' and '-reserve' can be used.  These may occur in any 
  172. order and may be repeated (in which case their values will accumulate).
  173.  
  174. Each of these four options must be followded by an additional argument 
  175. giving the amount of memory to allocate.  This should be a decimal integer 
  176. optionally followed by one of the characters  'k', 'K', 'm', 'M' or '%'.
  177. If one of the letters is given or the flag character is omitted, the 
  178. indicated number of bytes (resp. KBytes or MBytes) is allocated; if '%' is 
  179. given, the indicated percentage of not-yet-allocated memory is used. 
  180. Contiguous percentages refer to the same total amount.
  181.  
  182. If the command line doesn't include sizes for one or more of the three 
  183. areas, the total amount of memory which remains free after parsing of the 
  184. command line is distributed to the missing areas, using a ratio of 1:2:4 for
  185. the code, local and global area, respectively.    As mentioned above, this
  186. partitioning is not suitable for small-memory systems; for these, at least
  187. the code area has to be enlarged.
  188.  
  189. If some memory remains free after the partitioning, it will be returned to 
  190. the operating system.  This is especially important if other programs must 
  191. be run (either started from Prolog-68, or in a multi-tasking environment 
  192. like MiNT).  The '-reserve' option can be used to explicitly return a given 
  193. amount of memory; it must be followed by an argument in the format given 
  194. above.
  195.  
  196. The following examples assume that exactly 2 MByte of main memory are free
  197. at start-up:
  198.  
  199. -code 1M -global 50% -local 25%
  200.     1 MByte is assigned to the code area.  Of the remaining memory, 
  201.     half (512 KByte) is given to the global area, a quarter (256 KByte)
  202.     to the local area.  The remaining 256 KByte are returned to the 
  203.     operating system.
  204.  
  205. -code 25% -local 512K -code 25%
  206.     A quarter of the initial 2 MByte is assigned to the code area. 
  207.     Another 512 KByte go to the local area.  Of the remaining 1 MByte, 
  208.     another quarter is given to the code area.  The rest is assigned to 
  209.     the global area, since it has not been given a size.
  210.  
  211. No options given (default)
  212.     1/7 of total memory is assigned to the code area, 2/7 to the local 
  213.     area.  The remaining 4/7 go to the global area.  No memory is 
  214.     returned to the operating system.
  215.  
  216. ------- Predefined predicates -------------------------------------------------
  217.  
  218. I'm trying to create a complete Prolog system which is compatible to the
  219. upcoming ISO standard.    The current version was inspired mostly by Edinburgh
  220. Prolog and dialects derived from it, so many details are likely to change.
  221. Most predefined predicates have already been implemented, but here they can
  222. only be described in short:
  223.  
  224.     - Control:
  225.  
  226.     ','/2            (the usual control constructs)
  227.     ';'/2
  228.     '!'/2
  229.     '->'/2
  230.     call/1
  231.     '\+'/1            (non-provability, not a true negation)
  232.     once/1
  233.     true/0
  234.     otherwise/0        (= true/0)
  235.     fail/0
  236.     false/0         (= fail/0)
  237.     repeat/0
  238.     if_exception/3        (error handling)
  239.     signal_exception/1
  240.     signal_error/3
  241.     propagate_error/4
  242.     trap/2
  243.     set_error_handler/3
  244.  
  245.     The 'cut' works inside metacalls, but its scope is limited.  In
  246.     'call(X)', a 'cut' inside 'X' will have effect only inside the
  247.     parentheses.  A rule of thumb: `letters block the cut'.
  248.  
  249.     '->'/2 resembles a 'cut' which is restricted to part of a clause.
  250.     The call  (P -> Q; R)  can be used as an IF/THEN/ELSE statement:
  251.     If P can be satisfied, Q is called, otherwise R is called.
  252.     (P -> Q) on its own is identical to (P -> Q; fail).
  253.     The ISO standard requires a 'cut' within the precondition (P in the
  254.     example) not to have an effect on the rest of the clause.  Thus, the
  255.     above rule does NOT apply here!
  256.  
  257.     if_exception/3 and signal_exception/1 will be replaced by their ISO
  258.     equivalents (catch/3 and throw/1) in a future version.
  259.     The predicates signal_error/3, propagate_error/4, trap/2 and
  260.     set_error_handler/3 will by replaced by an ISO compatible error
  261.     handling mechanism.
  262.  
  263.     - Input/Output:
  264.  
  265.     read/1            (input/output of terms)
  266.     write/1
  267.     writeq/1
  268.     display/1        (always outputs to 'user'!)
  269.     write_canonical/1   (output in prefix form, also called displayq/1)
  270.     print/1         (output via portray/1, if defined by the user)
  271.     portray_clause/1    (prints clauses in easy-to-read format)
  272.  
  273.     get0/1            (input/output of characters)
  274.     get/1
  275.     skip/1            (*)
  276.     put/1            (*)
  277.     nl/0
  278.     tab/1            (* these predicates can take a parameter that is a
  279.                    full arithmetical expression)
  280.  
  281.     is_endfile/1        (specifies end-of-file character)
  282.     is_newline/1        (specifies end-of-line character)
  283.     is_newpage/1        (specifies end-of-page character)
  284.     is_endline/1        (detects end-of-line - must be called with its
  285.                  argument fully instantiated!)
  286.  
  287.     open/4            (management of input/output streams)
  288.     open/3
  289.     open_null_stream/1
  290.     close/1
  291.     current_stream/3
  292.     stream_property/2
  293.     nofileerrors/0
  294.     fileerrors/0
  295.     flush_output/1
  296.     set_input/1
  297.     set_output/1
  298.     current_input/1
  299.     current_output/1
  300.     absolute_file_name/2
  301.  
  302.     read/2            (input/output of terms to arbitrary streams)
  303.     write/2
  304.     writeq/2
  305.     display/2
  306.     write_canonical/2   (a.k.a. displayq/2)
  307.     print/2
  308.  
  309.     get0/2            (input/output of characters to arbitrary streams)
  310.     get/2
  311.     skip/2            (*)
  312.     put/2            (*)
  313.     nl/1
  314.     tab/2            (* see above)
  315.  
  316.     character_count/2   (inquiry about streams' status)
  317.     line_count/2
  318.     line_position/2
  319.     stream_position/2
  320.     set_stream_position/2
  321.     stream_position/3
  322.  
  323.     see/1            (Prolog-10 compatible file handling)
  324.     seeing/1
  325.     seen/0
  326.     tell/1
  327.     telling/1
  328.     told/0
  329.  
  330.     ttyget0/1        (Prolog-10 compatible terminal input/output)
  331.     ttyget/1
  332.     ttyskip/1
  333.     ttyput/1
  334.     ttynl/0
  335.     ttytab/1
  336.  
  337.     op/3            (define or delete operators)
  338.     current_op/3        (inquire current operators)
  339.  
  340.     sread/2         (read a term with its symbol table)
  341.     sread/3         (the same, using an arbitrary input stream)
  342.  
  343.     An (input or output) stream is a special object that can be created
  344.     using a call like
  345.  
  346.         open(+FileName, +Mode, -Stream)
  347.      or open(+FileName, +Mode, -Stream, +Options).
  348.  
  349.     `FileName' is the name of a file, `Mode' must be one of the atoms
  350.     'read', 'write' or 'append'.  `Options' if given must be a list of
  351.     options from the following set, indicating that some defaults should
  352.     be changed:
  353.  
  354.       type(Type)        The type of the data contained in the stream:
  355.                 either 'text' (Atari text format), 'utf' (text
  356.                 that can contain non-Atari characters), or
  357.                 'binary' (raw bytes).
  358.       alias(Alias)        An alias name for the stream (`Alias' must be
  359.                 an atom).
  360.       eof_action(Action)    What to do if an attempt is made to read past
  361.                 the end of a file; either 'error' (cause an
  362.                 error to occur), 'eof_code' (return the EOF
  363.                 indicator) or 'reset' (start over).
  364.       reposition        Present for compatibility only - in Prolog-68,
  365.                 all files opened by the user can be positioned.
  366.  
  367.     The stream returned by open/[3,4] can be used with e.g.
  368.  
  369.         write(+Stream, ?Term)
  370.     
  371.     and closed with
  372.  
  373.         close(+Stream).
  374.  
  375.     Besides file streams there are certain predefined streams, accessible
  376.     through the following names:
  377.  
  378.         user        (for compatibility)
  379.         user_input
  380.         user_output
  381.         user_error
  382.  
  383.     - Arithmetic
  384.  
  385.     'is'/2            (evaluate expressions)
  386.  
  387.     '=:='/2         (compare expressions)
  388.     '=\='/2
  389.     '<'/2
  390.     '=<'/2
  391.     '>'/2
  392.     '>='/2
  393.  
  394.     - Term classification:
  395.  
  396.     var/1
  397.     nonvar/1
  398.     atom/1
  399.     integer/1
  400.     atomic/1
  401.  
  402.     nonatomic/1        (negation of atomic/1)
  403.     composite/1        (composite term?)
  404.     simple/1        (negation of composite/1)
  405.     callable/1        (can term be called?)
  406.  
  407.     - Structure access:
  408.  
  409.     functor/3
  410.     arg/3
  411.     '=..'/2
  412.  
  413.     name/2            (conversion between constants and strings)
  414.     atom_chars/2
  415.     number_chars/2
  416.  
  417.     numbervars/3        (enumerate variables in a term, e.g., for write/1)
  418.  
  419.     - Comparison of arbitrary terms:
  420.  
  421.     '=='/2
  422.     '\=='/2
  423.     '@<'/2
  424.     '@=<'/2
  425.     '@>'/2
  426.     '@>='/2
  427.     compare/3
  428.     sort/2
  429.     msort/2
  430.     keysort/2
  431.  
  432.     When comparing terms with '@<', ..., '@>=', the following total
  433.     ordering relation over the set of all terms is used:
  434.  
  435.     a) Variables @< Numbers @< Atoms @< Composite Terms
  436.  
  437.     b) Variable1 @< Variable2   is uniquely defined, but has no further
  438.                     meaning to the user
  439.  
  440.     c) Number1 @< Number2        iff Number1 < Number2
  441.  
  442.     d) Atom1 @< Atom2        iff Atom1's name is lexicographically less
  443.                     than Atom2's name
  444.  
  445.     e) Term1 @< Term2        iff  i) Term1's arity is less than Term2's
  446.                         arity
  447.  
  448.                     ii) both arities are equal and
  449.                         functor(Term1) @< functor(Term2)
  450.  
  451.                        iii) both arities and both functors are
  452.                         equal and there exists an i
  453.                         such that for all j, 1 ≤ j < i:
  454.  
  455.                        argument(Term1, j) == argument(Term2, j)
  456.  
  457.                          and
  458.  
  459.                        argument(Term1, i) @< argument(Term2, i)
  460.  
  461.     compare/3 acts as if it were defined as
  462.  
  463.         compare('<', X, Y) :- X @< Y.
  464.         compare('=', X, Y) :- X == Y.
  465.         compare('>', X, Y) :- X @> Y.
  466.  
  467.     sort/2, msort/2 and keysort/2 sort lists according to the ordering
  468.     relation explained above.  sort/2 discards duplicate elements, msort/2
  469.     doesn't; keysort/2 expects a list of terms having the form
  470.  
  471.         Key - Value
  472.  
  473.     It ignores the 'Values' and uses the 'Keys' to sort the list.
  474.     keysort/2 keeps duplicate elements and preserves their original
  475.     ordering; for example,
  476.  
  477.         | ?- keysort([4-a, 1-b, 5-c, 1-d, 4-e, 0-f], Sorted).
  478.         Sorted = [0-f, 1-b, 1-d, 4-a, 4-e, 5-c]
  479.  
  480.     These predicates are at best linear, in the worst case they are
  481.     O(NlogN) (so we can safely conclude that they DON'T use 'quicksort').
  482.  
  483.     - Program loading:
  484.  
  485.     compile/1        (all predicates not declared dynamic are compiled)
  486.     consult/1        (just load, do not compile any predicates)
  487.     reconsult/1        (same as consult/1, present for compatibility)
  488.  
  489.     The following ISO-style directives are recognized (others will be
  490.     implemented in future versions):
  491.  
  492.       :-dynamic ...     (declare a predicate to be dynamic)
  493.       :-discontiguous ...    (not needed in Prolog-68)
  494.       :-include ...     (include a file)
  495.  
  496.     - Program status:
  497.  
  498.     listing/0        (list all dynamic predicates)
  499.     listing/1        (list some dynamic predicates)
  500.  
  501.     current_atom/1        (inquire known atoms etc.)
  502.     current_predicate/2
  503.     predicate_property/2
  504.  
  505.     halt/0            (halt the program)
  506.     halt/1            (ditto, specifying the exit code)
  507.     break            (start a new run level)
  508.     abort            (abort and return to Prolog top level)
  509.  
  510.     - Debugger:
  511.  
  512.     trace/0         (start debugger in creep mode)
  513.     debug/0         (start debugger in leap mode)
  514.     nodebug/0        (stop debugger)
  515.  
  516.     spy/1            (set & delete spy (=break) points)
  517.     nospy/1
  518.     leash/1
  519.     harness/1
  520.     debugging/1
  521.     unknown/2        (trap calls to undefined predicates)
  522.  
  523.     unknown(-OldAction, +NewAction)  is an abbreviation for
  524.     prolog_flag(unknown, -OldAction, +NewAction)  (which see).
  525.  
  526.     For more detailed informations concerning debugging, consult any
  527.     decent Prolog textbook.
  528.  
  529.     - Database operations:
  530.  
  531.     abolish/1        (completely delete predicates)
  532.     abolish/2
  533.     asserta/1        (add clauses to a dynamic predicate)
  534.     assertz/1
  535.     assert/1        (= asserta/1)
  536.     retract/1        (delete clauses of a dynamic predicate)
  537.     retractall/1
  538.     clause/2        (access clauses of a dynamic predicate)
  539.  
  540.     - Database references:
  541.  
  542.     Database references allow faster access to stored clauses, terms etc.
  543.  
  544.     asserta/2        (as above, also returning a database reference)
  545.     assertz/2
  546.     assert/2
  547.     clause/3
  548.  
  549.     instance/2        (given a reference, retrieve a clause or term)
  550.     erase/1         (given a reference, delete a clause or term)
  551.  
  552.     - Internal database:
  553.  
  554.     The internal database exists for reasons of efficiency.  It can only
  555.     be used for storing terms, not for storing clauses.
  556.  
  557.     recorda/3
  558.     recordz/3
  559.     recorded/3
  560.     current_key/2
  561.  
  562.     Using  recorda(+Key, +Term, -Ref)  resp.  recordz(+Key, +Term, -Ref),
  563.     the `Term' is stored in the internal database under `Key'.  A database
  564.     reference to the stored term is returned in `Ref'; it can be used to
  565.     remove the term via erase/1.  recorded(+Key, ?Term, ?Ref)  retrieves a
  566.     stored term,  current_key(?KeyName, ?KeyTerm)  inquires all known keys.
  567.  
  568.     - Set operations:
  569.  
  570.     setof/3 and bagof/3 have not been implemented yet.
  571.  
  572.     findall/3        (find all solutions of a goal)
  573.  
  574.     The difference between findall/3 and bagof/3 is the treatment of free
  575.     variables in the goal passed as parameter.  bagof/3 collects all
  576.     solutions that yield the same values for these variables, while
  577.     findall/3 regards all free variables as existentially quantified.
  578.  
  579.     - Grammar rules:
  580.  
  581.     expand_term/2        (Called before a clause is compiled; does
  582.                  transformation of grammar rules.  The user can
  583.                  define the predicate term_expansion/2 to make
  584.                  additional transformations.)
  585.  
  586.     phrase/3        (application of a grammar rule)
  587.     phrase/2
  588.  
  589.     phrase/[2,3] can handle an entire phrase (right-hand side of a
  590.     grammar rule).    phrase/2 is defined as
  591.  
  592.         phrase(Phrase, List) :- phrase(Phrase, List, []).
  593.  
  594.     - Miscellaneous:
  595.  
  596.     '='/2            (unification)
  597.     
  598.     length/2        (list operations)
  599.     member/2
  600.     memberchk/2
  601.     append/3
  602.  
  603.     prolog_flag/3        (inquire/modify global flags)
  604.     prolog_flag/2
  605.     prompt/2        (inquire/modify console input prompt)
  606.     statistics/0        (print statistics)
  607.     statistics/2        (inquire statistics)
  608.  
  609.     garbage_collect/0   (force garbage collection)
  610.     system/1        (pass an atom to a shell, e.g., Guläm)
  611.  
  612.     prolog_flag/2 and prolog_flag/3 access some global flags which are
  613.     used to control several internal features.  Contrary to other Prolog
  614.     systems, the value of a flag is always an integer (but this may change
  615.     in future versions).  The currently existing flags are:
  616.  
  617.     Name               Values (Default) Purpose
  618.  
  619.     character_escapes    0, 1    (0)    Controls evaluation of escape
  620.                         sequences on input and output
  621.     fileerrors        0, 1    (1)    Controls error handling when
  622.                         accessing nonexistent files
  623.     gc_trace        0, 1, 2 (0)    Controls amount of tracing
  624.                         information printed when the
  625.                         garbage collector is run
  626.                         (0=none, 1=terse, 2=verbose)
  627.     unknown         0, 1    (1)    Controls handling of undefined
  628.                         predicates (0=just fail,
  629.                         1=signal an error)
  630.     error_handling        0, 1, 2 (2)    Controls error handling
  631.                         (0=failure, 1=activation of
  632.                         error handling routine,
  633.                         2=additional error messages)
  634.  
  635.     prolog_flag(+Flag, -OldValue, +NewValue)  can be used to change the
  636.     value of the `Flag',  prolog_flag(?Flag, ?Value)  inquires such a value
  637.     without changing it.
  638.  
  639.     The first parameter to statistics/2 must be one of the following
  640.     keywords:
  641.  
  642.     'runtime'        inquire the running time
  643.  
  644.     'memory'        inquire the sizes of various memory areas
  645.     'core'            (some are duplicates, e.g., heap = program)
  646.     'program'
  647.     'heap'
  648.     'global_stack'
  649.     'local_stack'
  650.     'trail'
  651.  
  652.     'garbage_collection' garbage collection statistics (what else?)
  653.  
  654.     The second parameter is unified with a list of integers indicating the
  655.     results of the inquiry.
  656.  
  657. I know that this list is no sufficient documentation, but unfortunately I
  658. can't supply more at this time.  At least I'm working on a manual written in
  659. LaTeX.
  660.  
  661. ------- Miscellany ------------------------------------------------------------
  662.  
  663. Addresses:
  664.  
  665. German Federal Snail:    Jens Kilian
  666.             Holunderstraße 19
  667.         D-71083 Herrenberg
  668.             Germany
  669.  
  670. Internet:    jensk@hpbbn.bbn.hp.com
  671. MausNet:    Jens Kilian @ BB
  672.  
  673.  
  674. There are unreasonable people out there, so I must specifically disclaim any
  675. warranty even for this pre-release version:
  676.  
  677.                   NO WARRANTY
  678.  
  679. - BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
  680. FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
  681. OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
  682. PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
  683. OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  684. MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
  685. TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
  686. PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
  687. REPAIR OR CORRECTION.
  688.  
  689. - IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
  690. WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
  691. REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
  692. INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
  693. OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
  694. TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
  695. YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
  696. PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
  697. POSSIBILITY OF SUCH DAMAGES.
  698.  
  699.  
  700. My employers haven't even heard of Prolog-68, so don't waste effort on them.
  701.  
  702. -------------------------------------------------------------------------------
  703.  
  704.     Have fun,
  705.  
  706.         Jens Kilian
  707.